BicyclesController.updateBatchPositions - Code Metrics - Inspection of "Merge pull request #97 from KarlComSe/chore/docker..." - KarlComSe/SvenskaElsparkcyklarAB - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — development ( 62539b...739f83 )

by Vad

created 2025-01-17 11:03 UTC

BicyclesController.updateBatchPositions A

↳ Parent: BicyclesController

Complexity

Conditions

Size

Total Lines	21
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	19
dl	0
loc	21
ccs	5
cts	5
cp	1
crap	1
rs	9.45
c	0
b	0
f	0

import {
  Controller,
  Get,
  Post,
  Param,
  Patch,
  Body,
  Query,
  BadRequestException,
} from '@nestjs/common';
import {
  ApiBearerAuth,
  ApiOperation,
  ApiResponse,
  ApiParam,
  ApiBody,
  ApiTags,
  ApiQuery,
} from '@nestjs/swagger';
// we have removed all JwtAuthGuards from this route.
//  import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
import { BicyclesService } from './bicycles.service';
import { UpdateBicycleDto } from './dto/update-bicycle.dto';
import { Bicycle } from './entities/bicycle.entity';
import { BicycleResponse } from './types/bicycle-response.interface';
import { CreateBicycleDto } from './dto/create-bicycle.dto';
import { CityName } from 'src/cities/types/city.enum';
import {
  BatchUpdateBicyclePositionsDto,
  BicycleBatchResponseDto,
  BicyclePositionDto,

} from './dto/batch-update.dto';
import { BicycleBatchResponse } from './types/BicycleBatchResponse';


const BIKE_ID = 'b1e77dd3-9fb9-4e6c-a5c6-b6fc58f59464';
const BIKE_STATUS_AVAILABLE = 'Available';

const CREATED_AT = '2024-12-01T05:01:01.000Z';

const UPDATED_AT = '2024-12-07T18:30:30.000Z';

const UNAUTHORIZED_ERROR_MESSAGE = 'Unauthorized. Authentication required';
const CITY_ID_GOTHENBURG = '123e4567-e89b-12d3-a456-426614174000';


@ApiTags('Bicycles')
@Controller({ path: 'bike', version: '1' })
export class BicyclesController {
  constructor(private readonly bicyclesService: BicyclesService) {}

  @Get()
  @ApiBearerAuth()
  @ApiOperation({ summary: 'Get all bicycles' })
  @ApiQuery({
    name: 'city',
    required: false,
    enum: CityName,
  })
  @ApiQuery({ name: 'lat', required: false, minimum: -90, maximum: 90 })
  @ApiQuery({ name: 'lon', required: false, minimum: -180, maximum: 180 })
  @ApiQuery({ name: 'radius', required: false, minimum: 0, maximum: 100000 })
  @ApiResponse({
    status: 200,
    description: 'List of bicycles',
    type: [Bicycle],
  })
  @ApiResponse({
    status: 401,
    description: 'Unauthorized. Authentication required',
  })
  async getAllBicycles(
    @Query('lat') lat?: string,
    @Query('lon') lon?: string,
    @Query('radius') radius?: string,
    @Query('city') city?: CityName,
  ): Promise<BicycleResponse[]> {
    const latitude = lat ? parseFloat(lat) : undefined;
    const longitude = lon ? parseFloat(lon) : undefined;
    const radi = radius ? parseFloat(radius) : 3000;

    if ((latitude && !longitude) || (longitude && !latitude)) {
      throw new BadRequestException('Both lat and lon must be provided for location search');
    }

    if (city) {
      if (latitude) {
        return this.bicyclesService.toBicycleResponses(
          await this.bicyclesService.findByCityAndLocation(city, latitude, longitude, radi),
        );
      }
      return this.bicyclesService.toBicycleResponses(await this.bicyclesService.findByCity(city));
    }

    if (latitude) {
      return this.bicyclesService.toBicycleResponses(
        await this.bicyclesService.findByLocation(latitude, longitude, radi),
      );
    }

    return this.bicyclesService.toBicycleResponses(await this.bicyclesService.findAll());
  }

  @Post('create')
  @ApiBearerAuth()
  @ApiOperation({ summary: 'Create a new bicycle' })
  @ApiBody({
    type: CreateBicycleDto,
    description: 'Bicycle creation data',
    required: false,
  })
  @ApiResponse({
    status: 201,
    description: 'Bicycle created successfully',
    type: Bicycle,
  })
  async createABike(@Body() createBicycleDto: CreateBicycleDto): Promise<Bicycle> {
    console.log('skapa cykel');
    return await this.bicyclesService.createBike(createBicycleDto);
  }

  @Post('create-many')
  @ApiBearerAuth()
  @ApiOperation({
    summary: 'Create multiple bicycles',
    description:
      'Creates multiple bicycles in a single request. At least one bicycle must be provided.',
  })
  @ApiBody({
    type: [CreateBicycleDto],
    description: 'Array of bicycle creation data',
    required: true,
  })
  @ApiResponse({
    status: 201,
    description: 'Bicycles created successfully',
    type: [Bicycle],
  })
  @ApiResponse({
    status: 400,
    description: 'Bad Request - Empty array or invalid bicycle data provided',
  })
  async createManyBikes(@Body() createBicycleDto: CreateBicycleDto[]): Promise<Bicycle[]> {
    if (!createBicycleDto?.length) {
      throw new BadRequestException('At least one bike is required');
    }
    return await this.bicyclesService.createManyBikes(createBicycleDto);
  }

  @Get(':bikeId')
  @ApiBearerAuth()
  @ApiOperation({ summary: 'Get a bicycle by ID' })
  @ApiParam({
    name: 'bikeId',
    description: 'Unique identifier of the bicycle',
    type: 'string',
    example: BIKE_ID,
  })
  @ApiResponse({
    status: 200,
    description: 'Bicycle details retrieved successfully',
    type: Bicycle,
  })
  @ApiResponse({
    status: 401,
    description: UNAUTHORIZED_ERROR_MESSAGE,
  })
  @ApiResponse({
    status: 404,
    description: 'Bicycle not found',
  })
  async getBikeById(@Param('bikeId') id: string): Promise<Bicycle> {
    return await this.bicyclesService.findById(id);
  }

  @Patch(':bikeId')
  @ApiBearerAuth()
  @ApiOperation({ summary: 'Update bicycle by ID' })
  @ApiParam({
    name: 'bikeId',
    description: 'Unique identifier of the bicycle',
    type: 'string',
    example: BIKE_ID,
  })
  @ApiBody({
    description: 'Bicycle update details',
    type: UpdateBicycleDto,
  })
  @ApiResponse({
    status: 200,
    description: 'Bicycle updated successfully',
    type: Bicycle,
  })
  @ApiResponse({
    status: 400,
    description: 'Invalid input',
  })
  @ApiResponse({
    status: 404,
    description: 'Bicycle not found',
  })
  @ApiResponse({
    status: 401,
    description: UNAUTHORIZED_ERROR_MESSAGE,
  })
  async updateBicycle(@Param('bikeId') bikeId: string, @Body() updateBicycleDto: UpdateBicycleDto) {
    return this.bicyclesService.update(bikeId, updateBicycleDto);
  }

  @Patch('/batch/positions')
  @ApiOperation({ summary: 'Update multiple bicycle positions' })
  @ApiResponse({
    status: 200,
    description: 'Bicycle positions updated successfully',
    type: BicycleBatchResponseDto,
  })
  @ApiResponse({
    status: 400,
    description: 'Error: Bad Request (Invalid request payload)',
  })
  async updateBatchPositions(
    @Body() dto: BatchUpdateBicyclePositionsDto,
  ): Promise<BicycleBatchResponseDto> {
    const results = await this.bicyclesService.updatePositionsParallel(dto.updates);
    return {
      results,
      totalCount: results.length,
      successCount: results.filter((r) => r.success).length,
      failureCount: results.filter((r) => !r.success).length,
    };
  }

  @Get('city/:cityName')
  @ApiBearerAuth()
  @ApiOperation({ summary: 'Get all bicycles in a specific city' })
  @ApiResponse({
    status: 200,
    description: 'List of bicycles in the specified city',
    type: [Bicycle],
  })
  @ApiResponse({
    status: 401,
    description: UNAUTHORIZED_ERROR_MESSAGE,
  })
  @ApiParam({
    name: 'cityName',
    description: 'Name of the city',
    type: 'string',
    enum: CityName,
  })
  async getBicyclesByCity(@Param('cityName') cityName: CityName): Promise<Bicycle[]> {
    return await this.bicyclesService.findByCity(cityName);
  }
}


1	8	import {
2		Controller,
3		Get,
4		Post,
5		Param,
6		Patch,
7		Body,
8		Query,
9		BadRequestException,
10		} from '@nestjs/common';
11	8	import {
12		ApiBearerAuth,
13		ApiOperation,
14		ApiResponse,
15		ApiParam,
16		ApiBody,
17		ApiTags,
18		ApiQuery,
19		} from '@nestjs/swagger';
20		// we have removed all JwtAuthGuards from this route.
21		// import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
22	8	import { BicyclesService } from './bicycles.service';
23	8	import { UpdateBicycleDto } from './dto/update-bicycle.dto';
24	8	import { Bicycle } from './entities/bicycle.entity';
25		import { BicycleResponse } from './types/bicycle-response.interface';
26	8	import { CreateBicycleDto } from './dto/create-bicycle.dto';
27	8	import { CityName } from 'src/cities/types/city.enum';
28	8	import {
29		BatchUpdateBicyclePositionsDto,
30		BicycleBatchResponseDto,
31		BicyclePositionDto,
		0 ignored issues – show introduced 2025-01-11 00:49 UTC by Report Bug Copy Issue Report 'BicyclePositionDto' is defined but never used. Loading history...
32		} from './dto/batch-update.dto';
33		import { BicycleBatchResponse } from './types/BicycleBatchResponse';
		0 ignored issues – show introduced 2025-01-11 00:49 UTC by Report Bug Copy Issue Report 'BicycleBatchResponse' is defined but never used. Loading history...
34
35	8	const BIKE_ID = 'b1e77dd3-9fb9-4e6c-a5c6-b6fc58f59464';
36	8	const BIKE_STATUS_AVAILABLE = 'Available';
		0 ignored issues – show introduced 2025-01-02 13:12 UTC by Report Bug Copy Issue Report 'BIKE_STATUS_AVAILABLE' is assigned a value but never used. Loading history...
37	8	const CREATED_AT = '2024-12-01T05:01:01.000Z';
		0 ignored issues – show introduced 2025-01-02 13:12 UTC by Report Bug Copy Issue Report 'CREATED_AT' is assigned a value but never used. Loading history...
38	8	const UPDATED_AT = '2024-12-07T18:30:30.000Z';
		0 ignored issues – show introduced 2025-01-02 13:12 UTC by Report Bug Copy Issue Report 'UPDATED_AT' is assigned a value but never used. Loading history...
39	8	const UNAUTHORIZED_ERROR_MESSAGE = 'Unauthorized. Authentication required';
40	8	const CITY_ID_GOTHENBURG = '123e4567-e89b-12d3-a456-426614174000';
		0 ignored issues – show introduced 2025-01-02 13:12 UTC by Report Bug Copy Issue Report 'CITY_ID_GOTHENBURG' is assigned a value but never used. Loading history...
41
42		@ApiTags('Bicycles')
43		@Controller({ path: 'bike', version: '1' })
44	8	export class BicyclesController {
45	9	constructor(private readonly bicyclesService: BicyclesService) {}
46
47		@Get()
48		@ApiBearerAuth()
49		@ApiOperation({ summary: 'Get all bicycles' })
50		@ApiQuery({
51		name: 'city',
52		required: false,
53		enum: CityName,
54		})
55		@ApiQuery({ name: 'lat', required: false, minimum: -90, maximum: 90 })
56		@ApiQuery({ name: 'lon', required: false, minimum: -180, maximum: 180 })
57		@ApiQuery({ name: 'radius', required: false, minimum: 0, maximum: 100000 })
58		@ApiResponse({
59		status: 200,
60		description: 'List of bicycles',
61		type: [Bicycle],
62		})
63		@ApiResponse({
64		status: 401,
65		description: 'Unauthorized. Authentication required',
66		})
67	8	async getAllBicycles(
68		@Query('lat') lat?: string,
69		@Query('lon') lon?: string,
70		@Query('radius') radius?: string,
71		@Query('city') city?: CityName,
72		): Promise<BicycleResponse[]> {
73	4	const latitude = lat ? parseFloat(lat) : undefined;
74	4	const longitude = lon ? parseFloat(lon) : undefined;
75	4	const radi = radius ? parseFloat(radius) : 3000;
76
77	5	if ((latitude && !longitude) \|\| (longitude && !latitude)) {
78	1	throw new BadRequestException('Both lat and lon must be provided for location search');
79		}
80
81	3	if (city) {
82	1	if (latitude) {
83		return this.bicyclesService.toBicycleResponses(
84		await this.bicyclesService.findByCityAndLocation(city, latitude, longitude, radi),
85		);
86		}
87	1	return this.bicyclesService.toBicycleResponses(await this.bicyclesService.findByCity(city));
88		}
89
90	2	if (latitude) {
91	1	return this.bicyclesService.toBicycleResponses(
92		await this.bicyclesService.findByLocation(latitude, longitude, radi),
93		);
94		}
95
96	1	return this.bicyclesService.toBicycleResponses(await this.bicyclesService.findAll());
97		}
98
99		@Post('create')
100		@ApiBearerAuth()
101		@ApiOperation({ summary: 'Create a new bicycle' })
102		@ApiBody({
103		type: CreateBicycleDto,
104		description: 'Bicycle creation data',
105		required: false,
106		})
107		@ApiResponse({
108		status: 201,
109		description: 'Bicycle created successfully',
110		type: Bicycle,
111		})
112	8	async createABike(@Body() createBicycleDto: CreateBicycleDto): Promise<Bicycle> {
113	1	console.log('skapa cykel');
114	1	return await this.bicyclesService.createBike(createBicycleDto);
115		}
116
117		@Post('create-many')
118		@ApiBearerAuth()
119		@ApiOperation({
120		summary: 'Create multiple bicycles',
121		description:
122		'Creates multiple bicycles in a single request. At least one bicycle must be provided.',
123		})
124		@ApiBody({
125		type: [CreateBicycleDto],
126		description: 'Array of bicycle creation data',
127		required: true,
128		})
129		@ApiResponse({
130		status: 201,
131		description: 'Bicycles created successfully',
132		type: [Bicycle],
133		})
134		@ApiResponse({
135		status: 400,
136		description: 'Bad Request - Empty array or invalid bicycle data provided',
137		})
138	8	async createManyBikes(@Body() createBicycleDto: CreateBicycleDto[]): Promise<Bicycle[]> {
139	1	if (!createBicycleDto?.length) {
140		throw new BadRequestException('At least one bike is required');
141		}
142		return await this.bicyclesService.createManyBikes(createBicycleDto);
143		}
144
145		@Get(':bikeId')
146		@ApiBearerAuth()
147		@ApiOperation({ summary: 'Get a bicycle by ID' })
148		@ApiParam({
149		name: 'bikeId',
150		description: 'Unique identifier of the bicycle',
151		type: 'string',
152		example: BIKE_ID,
153		})
154		@ApiResponse({
155		status: 200,
156		description: 'Bicycle details retrieved successfully',
157		type: Bicycle,
158		})
159		@ApiResponse({
160		status: 401,
161		description: UNAUTHORIZED_ERROR_MESSAGE,
162		})
163		@ApiResponse({
164		status: 404,
165		description: 'Bicycle not found',
166		})
167	8	async getBikeById(@Param('bikeId') id: string): Promise<Bicycle> {
168	1	return await this.bicyclesService.findById(id);
169		}
170
171		@Patch(':bikeId')
172		@ApiBearerAuth()
173		@ApiOperation({ summary: 'Update bicycle by ID' })
174		@ApiParam({
175		name: 'bikeId',
176		description: 'Unique identifier of the bicycle',
177		type: 'string',
178		example: BIKE_ID,
179		})
180		@ApiBody({
181		description: 'Bicycle update details',
182		type: UpdateBicycleDto,
183		})
184		@ApiResponse({
185		status: 200,
186		description: 'Bicycle updated successfully',
187		type: Bicycle,
188		})
189		@ApiResponse({
190		status: 400,
191		description: 'Invalid input',
192		})
193		@ApiResponse({
194		status: 404,
195		description: 'Bicycle not found',
196		})
197		@ApiResponse({
198		status: 401,
199		description: UNAUTHORIZED_ERROR_MESSAGE,
200		})
201	8	async updateBicycle(@Param('bikeId') bikeId: string, @Body() updateBicycleDto: UpdateBicycleDto) {
202	1	return this.bicyclesService.update(bikeId, updateBicycleDto);
203		}
204
205		@Patch('/batch/positions')
206		@ApiOperation({ summary: 'Update multiple bicycle positions' })
207		@ApiResponse({
208		status: 200,
209		description: 'Bicycle positions updated successfully',
210		type: BicycleBatchResponseDto,
211		})
212		@ApiResponse({
213		status: 400,
214		description: 'Error: Bad Request (Invalid request payload)',
215		})
216	8	async updateBatchPositions(
217		@Body() dto: BatchUpdateBicyclePositionsDto,
218		): Promise<BicycleBatchResponseDto> {
219	1	const results = await this.bicyclesService.updatePositionsParallel(dto.updates);
220	1	return {
221		results,
222		totalCount: results.length,
223	2	successCount: results.filter((r) => r.success).length,
224	2	failureCount: results.filter((r) => !r.success).length,
225		};
226		}
227
228		@Get('city/:cityName')
229		@ApiBearerAuth()
230		@ApiOperation({ summary: 'Get all bicycles in a specific city' })
231		@ApiResponse({
232		status: 200,
233		description: 'List of bicycles in the specified city',
234		type: [Bicycle],
235		})
236		@ApiResponse({
237		status: 401,
238		description: UNAUTHORIZED_ERROR_MESSAGE,
239		})
240		@ApiParam({
241		name: 'cityName',
242		description: 'Name of the city',
243		type: 'string',
244		enum: CityName,
245		})
246	8	async getBicyclesByCity(@Param('cityName') cityName: CityName): Promise<Bicycle[]> {
247		return await this.bicyclesService.findByCity(cityName);
248		}
249		}
250

KarlComSe / SvenskaElsparkcyklarAB

Push — development ( 62539b...739f83 )

BicyclesController.updateBatchPositions A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like